NickelEval.jl

Julia FFI bindings for Nickel configuration language
Log | Files | Refs | README | LICENSE

examples.md (2183B)


      1 # Quick Examples
      2 
      3 ## Evaluating Expressions
      4 
      5 ```julia
      6 using NickelEval
      7 
      8 nickel_eval("1 + 2")        # => 3
      9 nickel_eval("true")          # => true
     10 nickel_eval("\"hello\"")     # => "hello"
     11 nickel_eval("null")          # => nothing
     12 ```
     13 
     14 Integers return `Int64`, decimals return `Float64`:
     15 
     16 ```julia
     17 nickel_eval("42")            # => 42 (Int64)
     18 nickel_eval("3.14")          # => 3.14 (Float64)
     19 ```
     20 
     21 ## Records
     22 
     23 Nickel records map to `Dict{String, Any}`:
     24 
     25 ```julia
     26 config = nickel_eval("""
     27 {
     28   host = "localhost",
     29   port = 8080,
     30   debug = true
     31 }
     32 """)
     33 
     34 config["host"]   # => "localhost"
     35 config["port"]   # => 8080
     36 config["debug"]  # => true
     37 ```
     38 
     39 Nested records work as expected:
     40 
     41 ```julia
     42 result = nickel_eval("{ database = { host = \"localhost\", port = 5432 } }")
     43 result["database"]["host"]  # => "localhost"
     44 ```
     45 
     46 ## Arrays
     47 
     48 Nickel arrays map to `Vector{Any}`:
     49 
     50 ```julia
     51 nickel_eval("[1, 2, 3]")              # => Any[1, 2, 3]
     52 nickel_eval("[\"a\", \"b\", \"c\"]")  # => Any["a", "b", "c"]
     53 ```
     54 
     55 Use the Nickel standard library for transformations:
     56 
     57 ```julia
     58 nickel_eval("[1, 2, 3] |> std.array.map (fun x => x * 2)")
     59 # => Any[2, 4, 6]
     60 ```
     61 
     62 ## Let Bindings and Functions
     63 
     64 ```julia
     65 nickel_eval("let x = 10 in x * 2")  # => 20
     66 
     67 nickel_eval("""
     68 let double = fun x => x * 2 in
     69 double 21
     70 """)  # => 42
     71 
     72 nickel_eval("""
     73 let add = fun x y => x + y in
     74 add 3 4
     75 """)  # => 7
     76 ```
     77 
     78 ## Record Merge
     79 
     80 Nickel's `&` operator merges records:
     81 
     82 ```julia
     83 nickel_eval("{ a = 1 } & { b = 2 }")
     84 # => Dict("a" => 1, "b" => 2)
     85 ```
     86 
     87 ## String Macro
     88 
     89 The `ncl"..."` macro provides a shorthand for `nickel_eval`:
     90 
     91 ```julia
     92 ncl"1 + 1"                  # => 2
     93 ncl"{ x = 10 }"["x"]        # => 10
     94 ncl"[1, 2, 3]"              # => Any[1, 2, 3]
     95 ```
     96 
     97 ## Evaluating Files
     98 
     99 Evaluate `.ncl` files directly. Imports are resolved relative to the file's directory:
    100 
    101 ```julia
    102 # config.ncl contains: { host = "localhost", port = 8080 }
    103 config = nickel_eval_file("config.ncl")
    104 config["host"]  # => "localhost"
    105 ```
    106 
    107 ## Error Handling
    108 
    109 Invalid Nickel code throws a `NickelError`:
    110 
    111 ```julia
    112 try
    113     nickel_eval("{ x = }")
    114 catch e
    115     if e isa NickelError
    116         println(e.message)  # Nickel's formatted error message
    117     end
    118 end
    119 ```