return gibt falschen wert zurück

[Dav1d]

Ahhh und ich hab mir extra nach Mühe gegeben, um auch Tuple zu plätten .. mal wieder: wer lesen kann löst Aufgaben besser

[BlackJack]

Die Freuden von sicheren, statisch typisierten Sprachen:
[codebox=text file=Unbenannt.txt]#[derive(Debug,Clone)]
enum Item {
Vector(Vec<Item>),
Number(u32),
Tupel((Box<Item>, Box<Item>)),
Bool(bool),
}

use Item::*;

fn flatten(item: Item) -> Item {
match item {
Vector(items) => {
let mut result: Vec<Item> = Vec::with_capacity(items.len());
for item in items {
match flatten(item) {
Vector(mut flattened) => result.append(&mut flattened),
x @ _ => panic!("unexpected item {:?}", x),
}
}
Vector(result)
},
_ => Vector(vec![item]),
}
}

fn main() {
let egg = Vector(vec![
Number(3), Number(4), Vector(vec![Vector(vec![Number(5)])])
]);
let spam = Vector(vec![
Vector(vec![
Vector(vec![Number(1), Number(2), egg.clone()]),
Tupel((Box::new(Number(6)), Box::new(Vector(vec![Number(7)])))),
Number(8)
]),
Number(9),
Bool(false)
]);
println!("{:?}", egg);
println!("{:?}", spam);

println!("\n{:?}", flatten(egg));
println!("{:?}", flatten(spam));
}[/code]
Nur a) weil Rust einen stäkeren Fokus auf funktionale Programmierung legt, und das ganze mit Zustand noch umständlicher zu schreiben wäre.

[Dav1d]

Ich bin mir nicht sicher was ich von Rust halten soll, manche Sachen finde ich genial aber irgendwie kommt es mir so vor als würde sich die Sprache gegen einen wenden wenn man tatsächlich mit ihr Code schreiben will.

Und warum kann die dumme Codebox kein Rust

[BlackJack]

@Dav1d: Was das hier so unschön macht, ist ja hauptsächlich das so viele verschiedene Datentypen nahezu beliebig verschachtelt werden können. Was bei dynamisch typisierten Sprachen halt deutlich weniger Probleme macht.

Geshi, der Syntaxhighlighter der vom Forum verwendet wird, ”kann” in seiner aktuellen Version zwar Rust, aber leider alles andere als fehlerfrei.

[pillmuncher]

Clojure:[codebox=clojure file=Unbenannt.txt](ns fl.core)

(defn flat- [li]
(cond
(not (list? li)) (list li)
(empty? li) ()
:else (concat (flat- (first li)) (flat- (rest li)))))

(defn flat [li]
(if (list? li)
(flat- li)
li))

(defn -main [& args]
(print (flat '(1 2 ((3 4) ((5) 6))))))[/code]Ergebnis:[codebox=bash file=Unbenannt.bsh]$ lein run
(1 2 3 4 5 6)[/code]

[BlackJack]

Auch in Richtung Lisp allerdings näher an Python dran:
[codebox=clojure file=Unbenannt.txt]#!/usr/bin/env hy


(defn flatten [items]
(if (instance? list items)
(let [result []]
(for [item items] (.extend result (flatten item)))
result)
[items]))


(defn flatten! [items]
(let [result []
f (fn [xs]
(if (instance? list xs)
(for [x xs] (f x))
(.append result xs)))]
(f items)
(assoc items (slice None) result)))


(defmain [&rest argv]
(let [egg [3 4 [[5]]]
spam [[[1 2 egg] (, 6 [7]) 8] 9 False]]
(print (flatten egg))
(print (flatten spam))
(flatten! egg)
(print egg)
(print spam)
(flatten! spam)
(print spam)))[/code]