[a.....n]

Przegląd mniej znanych języków programowania z ostatnich 14 lat:

#programowanie #dlang #processing #iolang #nemerle #falcon #fantom #rust #ceylon #elixir #julia #picat


Przykłady kodu to oczywiście sito eratostenesa


#################################

D Programming Language (2000)

http://dlang.org/

https://en.wikipedia.org/wiki/D_%28programming_language%29

Język ogólnego zastosowania, w tym do programowania systemowego. Fani mówią o nim, że jest tym czym C++ chciałby być.

Paradygmaty:

Programowanie Imperatywne

Programowanie Strukturalne

Programowanie Obiektowe

Programowanie Funkcyjne

Programowanie Proceduralne

Programowanie Generyczne

import
```**```
 std.stdio, std.algorithm, std.range, std.functional;

```**```
uint
```**```
[] sieve(
```**```
in
```**```
 
```**```
uint
```**```
 limit) 
```**```
nothrow
```**```
 @safe {

    
```**```
if
```**```
 (limit < 2)

        
```**```
return
```**```
 [];

    
```**```
auto
```**```
 composite = 
```**```
new
```**```
 
```**```
bool
```**```
[limit];

    
```**```
foreach
```**```
 (immutable 
```**```
uint
```**```
 n; 2 .. 
```**```
cast
```**```
(
```**```
uint
```**```
)(limit ^^ 0.5) + 1)

        
```**```
if
```**```
 (!composite[n])

            
```**```
for
```**```
 (
```**```
uint
```**```
 k = n * n; k < limit; k += n)

                composite[k] = 
```**```
true
```**```
;

    //return iota(2, limit).filter!(not!composite).array;

    
```**```
return
```**```
 iota(2, limit).filter!(i => !composite[i]).array;

}

```**```
void
```**```
 main() {

    50.sieve.writeln;

}

```#################################Processing (2001)[http://www.processing.org/](http://www.processing.org/)[https://en.wikipedia.org/wiki/Processing_%28programming_language%29](https://en.wikipedia.org/wiki/Processing_%28programming_language%29)Język programowania (oraz IDE) do tworzenia sztuki nowoczesnej, manipulacji grafiką i wizualizacji.Paradygmaty:Programowanie ProceduralneProgramowanie StrukturalneProgramowanie Obiektowe_```
int
```_```
 
```_```
maxx
```_```
,
```_```
maxy
```_```
;

```_```
int
```_```
 
```_```
max
```_```
;

```_```
boolean
```_```
[] 
```_```
sieve
```_```
;

```_```
void
```_```
 plot(
```_```
int
```_```
 
```_```
pos
```_```
, 
```_```
boolean
```_```
 
```_```
active
```_```
) {

  set(
```_```
pos
```_```
%maxx,pos/maxx, active?
```#```
000000:
```#```
ffffff);

}

```_```
void
```_```
 setup() {

  size(1000, 1000, P2D);

  frameRate(2);

  
```_```
maxx
```_```
=
```_```
width
```_```
;

  
```_```
maxy
```_```
=
```_```
height
```_```
;

  
```_```
max
```_```
=
```_```
width
```_```
*
```_```
height
```_```
;

  
```_```
sieve
```_```
=
```_```
new
```_```
 
```_```
boolean
```_```
[
```_```
max
```_```
+1];

  
```_```
sieve
```_```
[1]=
```_```
false
```_```
;

  plot(0,
```_```
false
```_```
);

  plot(1,
```_```
false
```_```
);

  for(
```_```
int
```_```
 
```_```
i
```_```
=2;
```_```
i<=max
```_```
;
```_```
i++
```_```
) {

    
```_```
sieve
```_```
[
```_```
i
```_```
]=
```_```
true
```_```
;

    plot(
```_```
i
```_```
,
```_```
true
```_```
);

  }

}

```_```
int
```_```
 
```_```
i
```_```
=2;

```_```
void
```_```
 draw() {

  if(!
```_```
sieve
```_```
[
```_```
i
```_```
]) {

    while(
```_```
i
```_```
*
```_```
i
```_```
<
```_```
max
```_```
 
```_```
&&
```_```
 !
```_```
sieve
```_```
[
```_```
i
```_```
]) {

      
```_```
i++
```_```
;

    }

  }

  if(
```_```
sieve
```_```
[
```_```
i
```_```
]) {

    print(
```_```
i+" "
```_```
);

    for(
```_```
int
```_```
 
```_```
j
```_```
=
```_```
i
```_```
*
```_```
i
```_```
;
```_```
j<=max
```_```
;
```_```
j+=i
```_```
) {

      if(
```_```
sieve
```_```
[
```_```
j
```_```
]) {

        
```_```
sieve
```_```
[
```_```
j
```_```
]=
```_```
false
```_```
;

        plot(
```_```
j
```_```
,
```_```
false
```_```
);

      }

    }

  }

  if(
```_```
i
```_```
*
```_```
i
```_```
<
```_```
max
```_```
) {

    
```_```
i++
```_```
;

  } 
```_```
else
```_```
 {

    noLoop();

    println(
```_```
"finished"
```_```
);

  }

}

```#################################Io (2002)[http://iolanguage.org/](http://iolanguage.org/)[https://en.wikipedia.org/wiki/Io_%28programming_language%29](https://en.wikipedia.org/wiki/Io_%28programming_language%29)Język ogólnego zastosowania bazujący na "wszystko jest obiektem".Paradygmaty:Programowanie ObiektoweProgramowanie Prototypowane (prototype-based language)```

Range

n := 120

primes := 2 to(n+1) asList

primes foreach(p, 
```**```
for
```**```
(i, p, n+1, 
```**```
if
```**```
(primes contains(p*i), primes remove(p*i))))

primes println

```#################################Nemerle (2003)[http://nemerle.org/](http://nemerle.org/)[https://en.wikipedia.org/wiki/Nemerle](https://en.wikipedia.org/wiki/Nemerle)Język ogólnego zastosowania stworzony przez Polaków na Uniwersytecie Wrocławskim.Paradygmaty:Programowanie imperatywneProgramowanie strukturalneProgramowanie obiektoweProgramowanie funkcyjne!Poniżej są chyba dwie implementacje, ale sobie głowy uciąć nie dam ;D```

primes@ (_:tpr) = 2: 3: (concatMap (uncurry genMap) $ zip primes tpr) 

``````

-- This function actually 
```**```
is
```**```
 optimization genMap ' (see more low) 

genMap 2 3 = [5,7] - special case, even p0^2 

genMap p0 p1 = arrayFilter lo lo ' $ accum (flip const) 

    (listArray (lo ', hi '-1) $ 
```**```
repeat
```**```
 True:: UArray Integer Bool) 

    [(j, False) 

    | i <- takeWhile (
    , j <- takeWhile (
        (i * (incIfEven $ correctRem $ lo 
```quotRem ```
 i)) 
```quot ```
 2 

    ]

    
```**```
where
```**```
 

    lo = p0^2; hi = p1^2 

    lo ' = lo 
```quot ```
 2; hi ' = hi 
```quot ```
 2 

    correctRem (q, 0) = q 

    correctRem (q, _) = q+1 

    incIfEven n 

        | even n = n+1 

        | 
```**```
otherwise
```**```
 = n 

    arrayFilter n i a 

        | i == hi ' = [] 

        | a! i = n: arrayFilter (n+2) (i+1) a 

        | 
```**```
otherwise
```**```
 = arrayFilter (n+2) (i+1) a 

``````

-- So the initiating 
```**```
variant
```**```
 genMap 
```**```
with
```**```
 a filtration of lists looked: 

genMap ' 2 3 = [5,7] - a special case, 2^2=4 - an even number 

genMap ' p0 p1 = - implementation of the sieve of Eratosthenes on lazy lists 

    foldl - convolution at the left the 
```**```
list
```**```
 of potential prime numbers 
```**```
with
```**```
 the 
```**```
list
```**```
 of already known prime numbers 

        (\l i-> 
```**```
fun
```**```
 l i (i * (quot lo i))) - application of the function filtering composite numbers 

        [lo, lo+2. hi-2] - the 
```**```
list
```**```
 of odd numbers from p0^2 to (p1^2-2) (from it composite numbers will be eliminated) 

        (takeWhile (**

list

**

 of prime numbers smaller p1 

**

where

**

    lo = p0^2; hi = p1^2 

    -- 

**

fun

**

 strikes off the 

**

list

**

 all numbers multiple d, since c 

**

fun

**

 []  = [] 

**

fun

**

 l@ (h:t) d c 

        | h == c = 

**

fun

**

 t d (c+d) 

        | h> c = 

**

fun

**

 l d (c+d) 

        | 

**

otherwise

**

 = h: 

**

fun

**

 t d c 

primes' (_:tpr) = 2: 3: (concatMap (uncurry genMap ') $ zip primes' tpr) 

#################################

Falcon (2003)

[http://www.falconpl.org/](http://www.falconpl.org/)

[https://en.wikipedia.org/wiki/Falcon_%28programming_language%29](https://en.wikipedia.org/wiki/Falcon_%28programming_language%29)

Język ogólnego zastosowanie w którym znajdziemy praktycznie wszystkie pomysły z innych języków :)

Paradygmaty:

Programowanie Proceduralne

Programowanie Obiektowe

Programowanie Funkcyjne

Programowanie Prototypowane

Programowanie przez przekazywanie wiadomości

Programowanie Zorientowane na Tabele

 /*

   FALCON - Benchmarks

   FILE: sieve.fal

   Timed Sieve of Eratosthenes.



   Measures performance how many computational loops are performed

   in  a given amount of time.



   See also "sieve_mt.fal"

   -------------------------------------------------------------------

   Author: Giancarlo Niccolai

   Begin:

   -------------------------------------------------------------------

   (C) Copyright 2008: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.

*/

// Config

const SIZE = 8092

const BATCH = 100

const TIME = 30

flags = arrayBuffer( SIZE+1 )

//=========================

// The sieve

//=========================

function sieve()

   global count

   flags.fill(0)

   for i in [1:SIZE+1]

      if flags[i]: continue



      prime = 2 * i + 1

      start = prime + i

      for k in [start:SIZE+1:prime]

         flags[k] = 1

      end

   end

   count += i

end

//=========================

// Main code

//=========================

count = 0

cycles = 0

t = seconds()

//while seconds() < t + TIME   // Test for TIME (30) seconds

    for iter in [0:BATCH]

       sieve()

    end

    cycles += BATCH

//end

t = seconds() - t

f = Format( ".3" )

 f.format( t ), " seconds."

 count, " sieves."

 f.format(count / t), " sieves per second" 

#################################

Fantom (2007)

[http://fantom.org/](http://fantom.org/)

[https://en.wikipedia.org/wiki/Fantom_%28programming_language%29](https://en.wikipedia.org/wiki/Fantom_%28programming_language%29)

Język ogólnego zastosowania który można uruchomić na maszynach wirtualnych Javy, JavaScript i .NET CLR

Paradygmaty:

Programowanie Strukturalne

Programowanie Obiektowe

Programowanie Funkcyjne

using concurrent

class PrimeNumbers

{



  Int startNumber := 100000000000



  Int numberToTest := 1000

  Str checkInterval := "0.3sec"



  Void main()

  {

    p := PrimeNumbers()

    p.test(10)

  }



  static Bool isPrime( Int primeCandidate)

  {

    for (i := 2; i < (primeCandidate.toFloat).sqrt.ceil.toInt+1; i++)

    {

      if (primeCandidate % i == 0) return false

    }

    return true

  }     



  Void test(Int numOfThreads)

  {

    apool := ActorPool {maxThreads = numOfThreads}

    [Int:Actor] actors := [:]

    [Int:Future] futures := [:]

    echo("creating Actors...")

    for (pc := startNumber; pc < startNumber+numberToTest; pc++)

    {

      actors[pc] = Actor(apool, |Int i->Bool|{isPrime(i)} )

    }

    t1 := Duration.nowTicks

    echo ("Sending Actors messages...")

    actors.each |a, pc| {futures[pc] = a.send(pc)}

    echo("Waiting for Actors to finish...")

    num := 0

    apool.stop //no new messages allowed to actors, allows pool to be done

    while (! apool.isDone)

    {

      num = 0

      futures.each { if (it.isDone) num++ }

      echo("$num actors finished")

      try

        apool.join(Duration.fromStr(checkInterval))

      catch(TimeoutErr e) {}

    }

    elapsedMs := (Duration.nowTicks - t1)/1000000

    num = 0

    futures.each { if (it.get) num++ }

    echo("Finished in ${elapsedMs}ms using $numOfThreads threads.") 

    echo("$num primes found in $numberToTest numbers tested")  

  }  

}      

#################################

Rust (2010)

[http://www.rust-lang.org/](http://www.rust-lang.org/)

[https://en.wikipedia.org/wiki/Rust_%28programming_language%29](https://en.wikipedia.org/wiki/Rust_%28programming_language%29)

Język programowania ogólnego zastosowania (w tym do programowania systemowego) opracowany w laboratoriach Mozilli.

Paradygmaty:

Programowanie Imperatywne

Programowanie Obiektowe

Programowanie Strukturalne

Programowanie Funkcyjne

**

use

**

 std::vec;

**

use

**

 std::num;

**

use

**

 std::iter;

**

fn

**

 intsqrt(n: 

**

uint

**

) -> 

**

uint

**

 {

    num::sqrt(n 

**

as

**

**

f64

**

) 

**

as

**

**

uint

**

}

**

fn

**

 simplesieve(limit: 

**

uint

**

) -> ~[

**

uint

**

] {

**

if

**

 limit < 2 {

**

return

**

 ~[];

    }

**

let

**

**

mut

**

 primes = vec::fromelem(limit + 1, 

**

true

**

);

**

for

**

 prime 

**

in

**

 iter::rangeinclusive(2, intsqrt(limit) + 1) {

**

if

**

 primes[prime] {

**

for

**

 multiple 

**

in

**

 iter::rangestep(prime * prime, limit + 1, prime) {

                primes[multiple] = 

**

false

**

            }

        }

    }

    iter::rangeinclusive(2, limit).filter(|&n| primes[n]).collect()

}

**

fn

**

 main() {

**

println

**

_

"{:?}"

_

, simplesieve(100))

}

#################################

Ceylon (2011)

[http://ceylon-lang.org/](http://ceylon-lang.org/)

[https://en.wikipedia.org/wiki/Ceylon_%28programming_language%29](https://en.wikipedia.org/wiki/Ceylon_%28programming_language%29)

Język ogólnego zastosowania stworzony przez Red Hat i uruchamiany na JVM.

Paradygmaty:

Programowanie Strukturalne

Programowanie Obiektowe

_

"Determine if 

n

 is a prime number."

_

throws (

class

AssertionException

, 

_

"if 

n<2

"

_

)

Boolean prime(Integer n) {

_

"

n

 must be greater than 1"

_

**

assert

**

 (n>1);

**

if

**

 (n<=3) {

**

return

**

**

true

**

;

    }

**

else

**

 if (n%2==0 || n%3==0) {

**

return

**

**

false

**

;

    }

**

else

**

 if (n<25) {

**

return

**

**

true

**

;

    }

**

else

**

 {

**

for

**

 (b 

**

in

**

 1..((n.float^0.5+1)/6).integer) {

**

if

**

 (n%(6*b-1)==0 || n%(6*b+1)==0) {

**

return

**

**

false

**

;

            }

        }

**

else

**

 {

**

return

**

**

true

**

;

        }

    }

}

**

void

**

 findPrimes(Integer n)

    => printAll { 

**

for

**

 (i 

**

in

**

 2..n) 

**

if

**

 (prime(i)) i };

#################################

Dart (2011)

[https://www.dartlang.org/](https://www.dartlang.org/)

[https://en.wikipedia.org/wiki/Dart_%28programming_language%29](https://en.wikipedia.org/wiki/Dart_%28programming_language%29)

Język przeznaczony do programowania aplikacji internetowych stworzony przez Google. Kompilowany do JavaScriptu. W zamyśle miał całkowicie wyeliminować JavaScript. Truestory.jpg

Paradygmaty:

Programowanie Strukturalne

Programowanie Obiektowe

// helper function to pretty print an Iterable

**

String

**

 iterableToString(Iterable seq) {

**

String

**

 str = 

_

"["

_

;

  Iterator i = seq.iterator;

**

if

**

 (i.moveNext()) str += i.current.toString();

**

while

**

(i.moveNext()) {

    str += 

_

", "

_

 + i.current.toString();

  }

**

return

**

 str + 

_

"]"

_

;

}



main() {

**

int

**

 limit = 1000;

**

int

**

 strt = 

**

new

**

 DateTime.now().millisecondsSinceEpoch;

  Set<

**

int

**

 sieve = 

**

new

**

 Set<

**

int

**

();

**

for

**

(

**

int

**

 i = 2; i <= limit; i++) {

    sieve.add(i);

  }

**

for

**

(

**

int

**

 i = 2; i * i <= limit; i++) {

**

if

**

(sieve.contains(i)) {

**

for

**

(

**

int

**

 j = i * i; j <= limit; j += i) {

       sieve.remove(j);

     }

   }

  }

**

var

**

 sortedValues = 

**

new

**

 List<

**

int

**

.from(sieve);

**

int

**

 elpsd = 

**

new

**

 DateTime.now().millisecondsSinceEpoch - strt;

  print(

_

"Found "

_

 + sieve.length.toString() + 

_

" primes up to "

_

 + limit.toString() +

_

" in "

_

 + elpsd.toString() + 

_

" milliseconds."

_

);

  print(iterableToString(sortedValues)); // expect sieve.length to be 168 up to 1000...

//  Expect.equals(168, sieve.length);

}

#################################

Elixir (2012)

[http://www.elixir-lang.org/](http://www.elixir-lang.org/)

[https://en.wikipedia.org/wiki/Elixir_%28programming_language%29](https://en.wikipedia.org/wiki/Elixir_%28programming_language%29)

Funkcyjny język programowania ogólnego zastosowania uruchamiany na EVM (wirtualnej maszynie erlanga).

Paradygmaty:

Programowanie Funkcyjne

Programowanie zorientowane na procesy

**

defmodule

**

 Sieve 

**

do

**

@doc

_

"""

  Generates a list of primes up to a given limit.

  """

_

  @spec primesto(nonneginteger) :: [nonneginteger]

**

def

**

 primesto(limit) 

**

do

**

Enum.tolist(2..limit) |> doprimes([]) |> Enum.reverse

**

end

**

**

defp

**

 doprimes([], primes), 

**

do

**

: primes

**

defp

**

 doprimes([ candidate | rest ], primes) 

**

do

**

candidates = Enum.reject(rest, &(rem(&1, candidate) == 0))

    do_primes(candidates, [ candidate | primes ])

**

end

**

**

end

**

#################################

Julia (2012)

[http://julialang.org/](http://julialang.org/)

[https://en.wikipedia.org/wiki/Julia_%28programming_language%29](https://en.wikipedia.org/wiki/Julia_%28programming_language%29)

Język przeznaczony do obliczeń naukowo-technicznych, współtworzony przez Stefana Karpińskiego

Paradygmaty:

Programowanie Obiektowe

Programowanie Strukturalne

Programowanie Proceduralne

Programowanie Funkcyjne

**

function

**

 eratosthenes(size)

    all=ones(

**

Int32

**

, size)   



    println(1)

    println(2)

    idx = 1

    prime = 3 

**

while

**

 prime <= size

**

if

**

 !

**

in

**

(prime, all)

            println(prime)

            idx += 1

            j = prime

**

while

**

 (j <= (size / prime)) 

                all = [all, prime * j]

                j += 1

**

end

**

**

end

**

        prime += 2

**

end

**

    println

**

end

**

#################################

Picat (2012)

[http://picat-lang.org/](http://picat-lang.org/)

Język ogólnego zastosowania.

Paradygmaty:

Programowanie Proceduralne

Programowanie Logiczne

myprimes(N)=L =>

    A=newarray(N),

    foreach(I in 2..floor(sqrt(N)))

        if (var(A[I])) then

            foreach(J in I**2..I..N)

                A[J]=0

            end

         end

     end,

     L=[I : I in 2..N, var(A[I])].