Kind1/CHANGELOG.md

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