## Kind 1.0.112

- Replace syntax is like rewrite, but equality is reversed

    replace x with e in goal

    This replaces the right side of the equality by the left side in the goal
    This should be more robust since it doesn't need to use mirror and, thus,
    avoids some holes

## Kind 1.0.108

- Allow "for" to be on the left side of a list comprehension

    [for x in [0 to 10] where Nat.is_even(x): x * 2]

## Kind 1.0.104

- Implicit arguments are here!

    ```
    id<A: $Type>(x: A): A
      x

    explicit: Nat
      id<$Nat>(7)

    implicit: Nat
      id(7)
    ```

- Nullary function call can be used instead of `!`

    ```
    let a = Map.new!
    let b = Map.new()
    ```

    This is helpful, because implicit arguments only trigger on calls.

## Kind 1.0.101

- Mutter syntax and improvements on the getter/setter syntax.

  Now you can get/set deeply nested fields.  For example, `list[0][0]` works and
  returns a `Maybe`, and `list[0][0] <- 7` works as expected. Moreover, the `<=`
  syntax can now be used to apply a function to the focused field. Example:

  ```
  type Bar {
    new(map: Map<List<List<Nat>>>)
  }

  type Foo {
    new(bar: Bar)
  }

  Test: Maybe<Nat>
    // Creates a value
    let a = Foo.new(Bar.new({"list": [[1,2,3],[4,5,6],[7,8,9]]}))

    // Applies a function to a nested element
    let a = a@bar@map{"list"}[0][0] <= Nat.mul(10)

    // Gets a nested element
    a@bar@map{"list"}[0][0]
  ```

### Kind 1.0.91

- Forall now demands `->`

- Now you can assign types in lambda parameters as in

    ```
    Test: _
      (x: Nat, y) x + y
    ```

### Kind 1.0.85

- Optimize BBT.for

### Kind 1.0.81

- Add Scheme compilation options to CLI

### Kind 1.0.79

- Socket UDP primitives

    Check Example.udp.sender and Example.udp.receiver

### Kind 1.0.75

- New syntaxes
    
    - Use

        use x = obj
        rest

        // Equivalent to:

        let x = obj
        open x
        rest

    - Let abort
        
        let x = maybe abort k
        rest

        // Equivalent to:

        case maybe as x {
          none: k
          some: 
            let x = x.value
            rest
        }

        // Also works with 'use'

    - List comprehension

        [x * 10 for x in [1, 2, 3]]

        // Returns:

        [10, 20, 30]

    - Map for-in:

        for key:val in map with state:
          loop
        rest

        let state = for key:val in map:
          loop
        rest

    - Function composition:

        f . g

        // Equivalent to:

        Function.comp!!!(f, g)

### Kind 1.0.64

- Monadic block improvements

  - Now it accepts most outside notations (let, open, log, for, etc.)

  - When you use a "for" without a "with", it becomes a monadic loop:
    
      IO {
        for i from 0 to 10:
          IO.print(Nat.show(i))
        for i from 100 to 110:
          IO.print(Nat.show(i))
      }
      
### Kind 1.0.63

- Generic derivers: stringifier, parser, serializer, deserializer. Example:

    ```
    type MyType {
      foo(n: List<Nat>, s: String, m: MyType)
      bar
    } deriving (stringifier, parser, serializer, deserializer)

    Test: _
      IO {
        let val = MyType.foo([1,2,3], "Hello", MyType.bar)

        // Converts to string
        let str = Stringifier.run!(MyType.stringifier, val)
        IO.print("str: " | str)

        // Parses string to a value
        let val = Parser.run!(MyType.parser, str) <> MyType.bar

        // Serializes to bits
        let bts = Serializer.run!(MyType.serializer, val)
        IO.print("bts: " | Bits.show(bts))

        // Deserializes to a value
        let val = Deserializer.run!(MyType.deserializer, bts) <> MyType.bar

        // Converts to string again
        let str = Stringifier.run!(MyType.stringifier, val)
        IO.print("str: " | str)
      }
    ```
    
      
### Kind 1.0.51

- Inference on numeric literals and binary operators. Check `SYNTAX.md`.

- Many bugfixes
     
      
### Kind 1.0.46

- New syntax to create, get and set attributes of records

```
type Foo {
  new(x: Nat, y: Nat)
}

Test: _
  let foo = {1,2}       // same as `Foo.new(1,2)`
  let x   = foo@x       // same as `case foo { new: foo.x }`
  let bar = foo@y <- 80 // same as `case foo { new: Foo.new(80,foo.y) }`
  bar
```