文章列表 > 你可能从未听说过的编程语言
你可能从未听说过的编程语言
  作者:uipower  发布时间:2016-09-28 15:36:45  

Uipower跟你一起来看一看,你可能最闻所未闻的5种编程语言吧。

1.Nim

我喜欢用Nim编码,是因为它很有意思。Nim模糊了编译和脚本语言之间的界线。下面是源代码:

proc update(options: Options) =
  ## Downloads the package list from the specified URL.
  ##
  ## If the download is successful, the global didUpdatePackages is set to
  ## true. Otherwise an exception is raised on error.
  let url =
    if options.action.typ == actionUpdate and options.action.optionalURL != "":
      options.action.optionalURL
    else:
      defaultPackageURL
  echo("Downloading package list from " & url)
  downloadFile(url, options.getNimbleDir() / "packages.json")
  echo("Done.")

还有长一点的:

proc parseConfig*(): Config =
  result = initConfig()
  var confFile = getConfigDir() / "nimble" / "nimble.ini"

  var f = newFileStream(confFile, fmRead)
  if f == nil:
    # Try the old deprecated babel.ini
    confFile = getConfigDir() / "babel" / "babel.ini"
    f = newFileStream(confFile, fmRead)
    if f != nil:
      echo("[Warning] Using deprecated config file at ", confFile)

  if f != nil:
    echo("Reading from config file at ", confFile)
    var p: CfgParser
    open(p, f, confFile)
    while true:
      var e = next(p)
      case e.kind
      of cfgEof:
        break
      of cfgSectionStart: discard
      of cfgKeyValuePair, cfgOption:
        case e.key.normalize
        of "nimbledir":
          # Ensure we don't restore the deprecated nimble dir.
          if e.value != getHomeDir() / ".babel":
            result.nimbleDir = e.value
        of "chcp":
          result.chcp = parseBool(e.value)
        else:
          raise newException(NimbleError, "Unable to parse config file:" &
                                  " Unknown key: " & e.key)
      of cfgError:
        raise newException(NimbleError, "Unable to parse config file: " & e.msg)
    close(p)

2.Felix

Felix是独一无二的。它是C ++、ML以及许多独特构想的结合。下面摘自我写的一个小型JSON解析器:

class JSON {
    typedef LineType = int;

    union Value =
        | Object of strdict[Value]
        | Array  of list[Value]
        | String of string
        | Number of double
        | True
        | False
        | Null
        | Error of string * LineType
    ;

    union Token =
        | TString of string
        | TNumber of double
        | TLBrace // {
        | TRBrace // }
        | TLBrak  // [
        | TRBrak  // ]
        | TColon  // :
        | TTrue   // true
        | TFalse  // false
        | TNull   // null
        | TEOF
        | TError of string * LineType
    ;

    instance Str[Token] {
        fun str(t: Token) => match t with
            | TString ?s => "TString \"" + s + "\""
            | TNumber ?n => "TNumber " + n.str
            | TLBrace    => "TLBrace"
            | TRBrace    => "TRBrace"
            | TLBrak     => "TLBrak"
            | TRBrak     => "TRBrak"
            | TColon     => "TColon"
            | TTrue      => "TTrue"
            | TFalse     => "TFalse"
            | TNull      => "TNull"
            | TEOF       => "TEOF"
            | TError (?s, ?i) => "error at line " + i.str + ": " + s
        endmatch;
    }

    proc lex(s: string, line: &LineType, outs: oschannel[Token]) = {
        line <- 1;

        proc tok(t: Token) => write $ outs, t;

        proc err(s: string) = {
            tok $ TError(s, *line);
            return from lex;
        };

        var i = 0.size;

        while i < s.len do
            while s.[i].isspace do
                if s.[i] == "\n" do *line++; done;
                i++;
                if i >= s.len goto eof;
            done;

            // number
            if s.[i].isnumeric or (i+1 < s.len and s.[i] == "-" and
                                     s.[i+1].isnumeric) do
                d := s.[i to].double;
                i += d.str.len;
                tok $ TNumber d;
            // string
            elif s.[i] == "\"" do
                i++;
                var st = "";
                while i < s.len and s.[i] != "\n" and s.[i] != "\"" do
                    st += s.[i];
                    i++;
                done;
                if s.[i] != "\"" call err "unterminated string literal";
                i++;
                tok $ TString st;
            // literals
            elif s.[i to i+4] == "true" do
                tok $ TTrue;
                i += 4.size;
            elif s.[i to i+5] == "false" do
                tok $ TFalse;
                i += 5.size;
            elif s.[i to i+4] == "null" do
                tok $ TNull;
                i += 4.size;
            // others
            else
                match s.[i].str with
                    | "{" => tok TLBrace;
                    | "}" => tok TRBrace;
                    | "[" => tok TLBrak;
                    | "]" => tok TRBrak;
                    | ":" => tok TColon;
                    | _   => err "unknown token";
                endmatch;

                i++;
            done;
        done;

        eof:>
        tok TEOF;
    }
}

你也可以鉴赏一下我写的这个JSON解析器,这是

它有一些很不错的功能,如schannels(一种协同程序)。 schannels就像Go的channels,不过并不是并发的。Felix还有另一个类似Go的channels,叫做fchannels,这是并发的。

Felix有一套不错的工具(Web服务器,明白易懂的编程格式,α-品质的图形配置工具)和尺寸刚好的标准库。

至于缺点?文档很少。不过,邮件讨论非常活跃。

3.Myrddin

Myrddin一些功能:

  • 类型推断
  • 模式匹配
  • Go风格slices切片
  • C风格的内存管理

举个libbio输入/输出库的例子。下面是其中的一个片段:

/*
writes to as much from `src` as possible to a file,
returning the number of bytes written.
*/
const write = {f, src
    std.assert(f.mode & Wr != 0, "File is not in write mode")
    /*
    Tack small writes onto the buffer end. Big ones
    flush the buffer and then go right to kernel.
    */
    if src.len < (f.wbuf.len - f.wend)
        std.slcp(f.wbuf[f.wend:f.wend+src.len], src)
        f.wend += src.len
        -> src.len
    else
        flush(f)
        -> writebuf(f.fd, src)
    ;;
}

4.K

K,连同Kona非常特别。它是将APL推进ASCII字符世界的结果。

下面是一些在Kona wiki的惯用语:

shuffle:{x@<>(#x)#1 0} / Perfect shuffle
mean:{(+/x)%#x} / Arithmetic mean
fac:*/1+!: / Factorial
fib:{x{x,+/-2#x}/!2} / Fibonacci
life:{|/(1;x)&3 4=\:+/,/2{-1 0 1!'\:x}/x} / Conway's Game of Life
sort:{x@<x} / Sort list
powerset:{x[&:'!2+&#x]} / Powerset

正如你所看到的,K非常简洁,就是可能有点太过了。然而,作为数组处理语言,它功能卓越,而且快速。

5.Objeck

Objeck用起来特别给力:

class Factorial {
    function : native : Factorial(n : Int) ~ Int {
        if (n <= 1) {
            return n;
        } else {
            return n * Factorial(n-1);
        };
    }

    function : Main(args : String[]) ~ Nil {
        "Number: "->Print();
        number := IO.Console->ReadString()->ToInt();
        if (number < 0) {
            "Number must be greater than 0"->PrintLine();
            Runtime->Exit(1);
        };
        Factorial(number)->PrintLine();
    }
}

它的缺点是没有真正的本地编译器。

其他

还有我没有提到过的ani和Alore。

Ani是一种隐含并行性和非常速度的的编程语言。而Alore是基于静态和动态类型自由组合的编程语言。

总结

我要介绍的就到这里,希望能能你眼前一亮。

  • 上海(总部)
  • 北京
  • 深圳

邮箱:uipower@uipower.com

电话:400-660-9989

UIPower公众号
  • CopyRight©2004-2017
  • 上海勇进软件有限公司
  • 沪ICP备05028907号