This project is purely an imagining of what it would be like to write Ethereum smart contracts in a typed, functional programming language. It is not yet implemented beyond an extremely rough PEGJS parser and a demo code generator.

---

A simple smart contract:

MyContractState : State { balance : Uint }

// declare a contract with a specific state type
MyContract : Contract MyContractState
MyContract = Contract

  // all contract methods take the contract state and return a new contract state
  deposit : MyContractState -> MsgValue -> MyContractState
  deposit state msgValue = MyContractState { balance = balance + msgValue }

  // dependent types can be imagined as a way to enforce constraints on effects
  // e.g. in order to send ether you must prove that there is enough ether to send
  send : MyContractState -> (amount : MsgValue) -> (to : Address) -> (MyContractState, EtherTransfer amount to balance)

  // descriptions of side effects are returned in a tuple with the new state.
  // it is a purely functional language
  send state amount to = (state, EtherTransfer amount to balance)

Equivalent contract in Solidity:

• Yes, this was actually produced by the demo compiler with the above input.
• It doesn't do any type-checking and will break on almost any other input. Really it's just a proof-of-concept.

contract MyContract {
  public uint balance;

  function deposit(msg.value)  {
    balance = balance + msg.value;
  }

  function send(amount, to)  {
    if(!to.value(amount).call()) throw;
  }
}

Usage

Generate solidity from the given sourcefile:

$ functional-solidity-language [sourcefile]

Generate just the parsed AST:

$ functional-solidity-language --parse [sourcefile]

Status

• Proof-of-concept parser
• Proof-of-concept code generator
• 1st gen parser
• 1st gen code generator

License

ISC © Raine Revere