mirror of
https://github.com/roc-lang/roc.git
synced 2025-12-23 08:48:03 +00:00
316 lines
7.6 KiB
Markdown
316 lines
7.6 KiB
Markdown
# META
|
|
~~~ini
|
|
description=Lambda parameters with unused variable checking
|
|
type=file
|
|
~~~
|
|
# SOURCE
|
|
~~~roc
|
|
app [main!] { pf: platform "../basic-cli/main.roc" }
|
|
|
|
# Lambda with unused parameter - should warn
|
|
add : U64 -> U64
|
|
add = |unused| 42
|
|
|
|
# Lambda with underscore parameter that is used - should warn
|
|
multiply : U64 -> U64
|
|
multiply = |_factor| _factor * 2
|
|
|
|
# Lambda with unused underscore parameter - should be fine
|
|
process : U64 -> U64
|
|
process = |_input| 100
|
|
|
|
# Lambda with used parameter - should be fine
|
|
double : U64 -> U64
|
|
double = |value| value * 2
|
|
|
|
main! = |_| {
|
|
result1 = add(5)
|
|
result2 = multiply(3)
|
|
result3 = process(7)
|
|
result4 = double(4)
|
|
result1 + result2 + result3 + result4
|
|
}
|
|
~~~
|
|
# EXPECTED
|
|
UNUSED VARIABLE - lambda_parameter_unused.md:5:8:5:14
|
|
UNDERSCORE VARIABLE USED - lambda_parameter_unused.md:9:22:9:29
|
|
# PROBLEMS
|
|
**UNUSED VARIABLE**
|
|
Variable `unused` is not used anywhere in your code.
|
|
|
|
If you don't need this variable, prefix it with an underscore like `_unused` to suppress this warning.
|
|
The unused variable is declared here:
|
|
**lambda_parameter_unused.md:5:8:5:14:**
|
|
```roc
|
|
add = |unused| 42
|
|
```
|
|
^^^^^^
|
|
|
|
|
|
**UNDERSCORE VARIABLE USED**
|
|
Variable `_factor` is prefixed with an underscore but is actually used.
|
|
|
|
Variables prefixed with `_` are intended to be unused. Remove the underscore prefix: `factor`.
|
|
|
|
**lambda_parameter_unused.md:9:22:9:29:**
|
|
```roc
|
|
multiply = |_factor| _factor * 2
|
|
```
|
|
^^^^^^^
|
|
|
|
|
|
# TOKENS
|
|
~~~zig
|
|
KwApp,OpenSquare,LowerIdent,CloseSquare,OpenCurly,LowerIdent,OpColon,KwPlatform,StringStart,StringPart,StringEnd,CloseCurly,
|
|
LowerIdent,OpColon,UpperIdent,OpArrow,UpperIdent,
|
|
LowerIdent,OpAssign,OpBar,LowerIdent,OpBar,Int,
|
|
LowerIdent,OpColon,UpperIdent,OpArrow,UpperIdent,
|
|
LowerIdent,OpAssign,OpBar,NamedUnderscore,OpBar,NamedUnderscore,OpStar,Int,
|
|
LowerIdent,OpColon,UpperIdent,OpArrow,UpperIdent,
|
|
LowerIdent,OpAssign,OpBar,NamedUnderscore,OpBar,Int,
|
|
LowerIdent,OpColon,UpperIdent,OpArrow,UpperIdent,
|
|
LowerIdent,OpAssign,OpBar,LowerIdent,OpBar,LowerIdent,OpStar,Int,
|
|
LowerIdent,OpAssign,OpBar,Underscore,OpBar,OpenCurly,
|
|
LowerIdent,OpAssign,LowerIdent,NoSpaceOpenRound,Int,CloseRound,
|
|
LowerIdent,OpAssign,LowerIdent,NoSpaceOpenRound,Int,CloseRound,
|
|
LowerIdent,OpAssign,LowerIdent,NoSpaceOpenRound,Int,CloseRound,
|
|
LowerIdent,OpAssign,LowerIdent,NoSpaceOpenRound,Int,CloseRound,
|
|
LowerIdent,OpPlus,LowerIdent,OpPlus,LowerIdent,OpPlus,LowerIdent,
|
|
CloseCurly,
|
|
EndOfFile,
|
|
~~~
|
|
# PARSE
|
|
~~~clojure
|
|
(file
|
|
(app
|
|
(provides
|
|
(exposed-lower-ident
|
|
(text "main!")))
|
|
(record-field (name "pf")
|
|
(e-string
|
|
(e-string-part (raw "../basic-cli/main.roc"))))
|
|
(packages
|
|
(record-field (name "pf")
|
|
(e-string
|
|
(e-string-part (raw "../basic-cli/main.roc"))))))
|
|
(statements
|
|
(s-type-anno (name "add")
|
|
(ty-fn
|
|
(ty (name "U64"))
|
|
(ty (name "U64"))))
|
|
(s-decl
|
|
(p-ident (raw "add"))
|
|
(e-lambda
|
|
(args
|
|
(p-ident (raw "unused")))
|
|
(e-int (raw "42"))))
|
|
(s-type-anno (name "multiply")
|
|
(ty-fn
|
|
(ty (name "U64"))
|
|
(ty (name "U64"))))
|
|
(s-decl
|
|
(p-ident (raw "multiply"))
|
|
(e-lambda
|
|
(args
|
|
(p-ident (raw "_factor")))
|
|
(e-binop (op "*")
|
|
(e-ident (raw "_factor"))
|
|
(e-int (raw "2")))))
|
|
(s-type-anno (name "process")
|
|
(ty-fn
|
|
(ty (name "U64"))
|
|
(ty (name "U64"))))
|
|
(s-decl
|
|
(p-ident (raw "process"))
|
|
(e-lambda
|
|
(args
|
|
(p-ident (raw "_input")))
|
|
(e-int (raw "100"))))
|
|
(s-type-anno (name "double")
|
|
(ty-fn
|
|
(ty (name "U64"))
|
|
(ty (name "U64"))))
|
|
(s-decl
|
|
(p-ident (raw "double"))
|
|
(e-lambda
|
|
(args
|
|
(p-ident (raw "value")))
|
|
(e-binop (op "*")
|
|
(e-ident (raw "value"))
|
|
(e-int (raw "2")))))
|
|
(s-decl
|
|
(p-ident (raw "main!"))
|
|
(e-lambda
|
|
(args
|
|
(p-underscore))
|
|
(e-block
|
|
(statements
|
|
(s-decl
|
|
(p-ident (raw "result1"))
|
|
(e-apply
|
|
(e-ident (raw "add"))
|
|
(e-int (raw "5"))))
|
|
(s-decl
|
|
(p-ident (raw "result2"))
|
|
(e-apply
|
|
(e-ident (raw "multiply"))
|
|
(e-int (raw "3"))))
|
|
(s-decl
|
|
(p-ident (raw "result3"))
|
|
(e-apply
|
|
(e-ident (raw "process"))
|
|
(e-int (raw "7"))))
|
|
(s-decl
|
|
(p-ident (raw "result4"))
|
|
(e-apply
|
|
(e-ident (raw "double"))
|
|
(e-int (raw "4"))))
|
|
(e-binop (op "+")
|
|
(e-binop (op "+")
|
|
(e-binop (op "+")
|
|
(e-ident (raw "result1"))
|
|
(e-ident (raw "result2")))
|
|
(e-ident (raw "result3")))
|
|
(e-ident (raw "result4")))))))))
|
|
~~~
|
|
# FORMATTED
|
|
~~~roc
|
|
app [main!] { pf: platform "../basic-cli/main.roc" }
|
|
|
|
# Lambda with unused parameter - should warn
|
|
add : U64 -> U64
|
|
add = |unused| 42
|
|
|
|
# Lambda with underscore parameter that is used - should warn
|
|
multiply : U64 -> U64
|
|
multiply = |_factor| _factor * 2
|
|
|
|
# Lambda with unused underscore parameter - should be fine
|
|
process : U64 -> U64
|
|
process = |_input| 100
|
|
|
|
# Lambda with used parameter - should be fine
|
|
double : U64 -> U64
|
|
double = |value| value * 2
|
|
|
|
main! = |_| {
|
|
result1 = add(5)
|
|
result2 = multiply(3)
|
|
result3 = process(7)
|
|
result4 = double(4)
|
|
result1 + result2 + result3 + result4
|
|
}
|
|
~~~
|
|
# CANONICALIZE
|
|
~~~clojure
|
|
(can-ir
|
|
(d-let
|
|
(p-assign (ident "add"))
|
|
(e-lambda
|
|
(args
|
|
(p-assign (ident "unused")))
|
|
(e-num (value "42")))
|
|
(annotation
|
|
(ty-fn (effectful false)
|
|
(ty-lookup (name "U64") (builtin))
|
|
(ty-lookup (name "U64") (builtin)))))
|
|
(d-let
|
|
(p-assign (ident "multiply"))
|
|
(e-lambda
|
|
(args
|
|
(p-assign (ident "_factor")))
|
|
(e-binop (op "mul")
|
|
(e-lookup-local
|
|
(p-assign (ident "_factor")))
|
|
(e-num (value "2"))))
|
|
(annotation
|
|
(ty-fn (effectful false)
|
|
(ty-lookup (name "U64") (builtin))
|
|
(ty-lookup (name "U64") (builtin)))))
|
|
(d-let
|
|
(p-assign (ident "process"))
|
|
(e-lambda
|
|
(args
|
|
(p-assign (ident "_input")))
|
|
(e-num (value "100")))
|
|
(annotation
|
|
(ty-fn (effectful false)
|
|
(ty-lookup (name "U64") (builtin))
|
|
(ty-lookup (name "U64") (builtin)))))
|
|
(d-let
|
|
(p-assign (ident "double"))
|
|
(e-lambda
|
|
(args
|
|
(p-assign (ident "value")))
|
|
(e-binop (op "mul")
|
|
(e-lookup-local
|
|
(p-assign (ident "value")))
|
|
(e-num (value "2"))))
|
|
(annotation
|
|
(ty-fn (effectful false)
|
|
(ty-lookup (name "U64") (builtin))
|
|
(ty-lookup (name "U64") (builtin)))))
|
|
(d-let
|
|
(p-assign (ident "main!"))
|
|
(e-closure
|
|
(captures
|
|
(capture (ident "add"))
|
|
(capture (ident "multiply"))
|
|
(capture (ident "process"))
|
|
(capture (ident "double")))
|
|
(e-lambda
|
|
(args
|
|
(p-underscore))
|
|
(e-block
|
|
(s-let
|
|
(p-assign (ident "result1"))
|
|
(e-call
|
|
(e-lookup-local
|
|
(p-assign (ident "add")))
|
|
(e-num (value "5"))))
|
|
(s-let
|
|
(p-assign (ident "result2"))
|
|
(e-call
|
|
(e-lookup-local
|
|
(p-assign (ident "multiply")))
|
|
(e-num (value "3"))))
|
|
(s-let
|
|
(p-assign (ident "result3"))
|
|
(e-call
|
|
(e-lookup-local
|
|
(p-assign (ident "process")))
|
|
(e-num (value "7"))))
|
|
(s-let
|
|
(p-assign (ident "result4"))
|
|
(e-call
|
|
(e-lookup-local
|
|
(p-assign (ident "double")))
|
|
(e-num (value "4"))))
|
|
(e-binop (op "add")
|
|
(e-binop (op "add")
|
|
(e-binop (op "add")
|
|
(e-lookup-local
|
|
(p-assign (ident "result1")))
|
|
(e-lookup-local
|
|
(p-assign (ident "result2"))))
|
|
(e-lookup-local
|
|
(p-assign (ident "result3"))))
|
|
(e-lookup-local
|
|
(p-assign (ident "result4")))))))))
|
|
~~~
|
|
# TYPES
|
|
~~~clojure
|
|
(inferred-types
|
|
(defs
|
|
(patt (type "U64 -> U64"))
|
|
(patt (type "U64 -> U64"))
|
|
(patt (type "U64 -> U64"))
|
|
(patt (type "U64 -> U64"))
|
|
(patt (type "_arg -> U64")))
|
|
(expressions
|
|
(expr (type "U64 -> U64"))
|
|
(expr (type "U64 -> U64"))
|
|
(expr (type "U64 -> U64"))
|
|
(expr (type "U64 -> U64"))
|
|
(expr (type "_arg -> U64"))))
|
|
~~~
|