const a: Array<Array<string>> = [["a"]]; const b: Array<Array<string>> = a.concat(["b"]); console.log(b);
[ [ 'a' ], 'b' ]
// Ceylon T[] concat<T>(T[] array, T[]|T values) { if (is T[] values) { return concatenate(array, values); } else { return concatenate(array, [values]); } } String[][] a = [["a"]]; String[][] b = concat<String[]>(a, ["b"]); print(b);
[[a], [b]]
Array<Array<String>>
だし)実際にはぶっ壊れた挙動になる。<String[]>
がないと正しく推論してくれなかったのが謎。interface URLRequest<T> { baseURL(): string; path(): string; method(): string; parameters(): { [index: string]: string; }; headers(): { [index: string]: string; }; parseResponse(response: HTTPResponse): T; }
さらに用途に合わせたHogeAPIRequestとしてURLRequestを継承させたinterfaceをbaseURLだけは固定のものを返したい、みたいな時に返せなくてprotocol extension欲しいな、となりました (edited)round
が予想外の挙動なんですが何か知ってる人いませんか? >>> a = round(3.14) >>> print(a) 3 >>> type(a) <class 'int'> >>> b = round(np.float64(3.14)) >>> print(b) 3.0 >>> type(b) <class 'numpy.float64'>
In [1]: a = np.round(3.14) In [2]: a Out[2]: 3.0 In [3]: print(a) 3.0
round(number, ndigits)
は number.__round__(ndigits)
に移譲します。__round__
メソッドが定義されているって話ではなくてですか?Self
だけ T
からバラして対応とる必要があるんだけどSelf
が Associated Type こみこみで具象化されるために それができないのと同様にself
も同じ仕様でできないんじゃい、という感じがするtrait Functor [ F [_] ]
ってやって、パターンマッチで Fだけを取れるんだけど<>
じゃないと定義できないよねAny<Sequence where .Element=String>
が出来るようになれば解決するtrait Foo { fn is_valid(&self) -> bool; fn is_invalid(&self) -> bool { !self.is_valid() } }
extension <E> Box<E> : From<E> where E : Error { }
(edited)extension Box : From where Box.Element : Error , Box.Element == From.Element { }
impl From<i8> for i16 impl From<i8> for i32 impl From<i8> for i64 impl From<i8> for isize impl From<i16> for i32 impl From<i16> for i64 impl From<i32> for i64 impl From<u8> for i16 impl From<u8> for i32 impl From<u8> for i64
tarunon - 2017/05/09 えっとですねー 原初の欲求としては、assoctypeに複数値を持たせたいんですよ omochimetaru - 2017/05/09 昨日話してた可変長ジェネリックか tarunon - 2017/05/09 複数種類の型を定義すると、複数種類の実装のオーバーロードで実現される。 これが出来るとですね、assoctypeで引数を束縛するような、2つの型の関係が 1:1,1:多しか今は出来ないが omochimetaru - 2017/05/09 Tuple2にある機能はTuple3にも全て欲しい、みたいな? tarunon - 2017/05/09 多:多が可能になる いや、タプルとは違うな Viewから実装を引っぺがして、それをGenericsに作ることで NibとGenerics型の共存が出来ないかなと考えてるところから派生してる これ自体は上手く行きそうなんだけど、Viewと実装の繋ぎ込みがfuncになっちゃって、型を書くのが怠いから、assoctypeで縛ろうとしたが… という感じ、Viewと実装をassoctypeに持つ第三の型を作ればいい気もするけど、登場人物はなるべく増やしたくない omochimetaru - 2017/05/09 よくわからないけど、型Aと型Xの組み合わせのときの処理を静的に定義したい、そのペア自体を型付けしたい? tarunon - 2017/05/09 extension View: HasImpl { typealias Impl=Int } ↑これだと、Intしか実装がない。なので、IntかStringを使おうとすると↓ extension View: HasImpl { typealias Impl=Int|String } ↑こういうのが欲しくなる そうそう omochimetaru - 2017/05/09 (A/B/C) x (X/Y/Z) のような合成がしたいと tarunon - 2017/05/09 そう! omochimetaru - 2017/05/09 で、(*) x (X) とか (A) x (X) とか (A/B) x (*) の場合における実装を定義したい?(編集済) tarunon - 2017/05/09 えーっと、そこの掛け算全部書くのは吝かではない(編集済) omochimetaru - 2017/05/09 なるほど あー、 A / B / C とかは個別の データモデル型とか 個別のViewだから enum にならんのか
trait Hoge<A> { fn aaa(&self) -> A; fn bbb(&self) -> i32; }
に対して、 Hoge<i32> と Hoge<String> で別々の aaa(), bbb() の実装を持てる例 (edited)rustc 1.18.0 (03fc9d622 2017-06-06) error[E0282]: type annotations needed --> <anon>:45:5 | 45 | call_hoge_generic(&cat); | ^^^^^^^^^^^^^^^^^ cannot infer type for `T` error: aborting due to previous error
call_hoge_generic::<i32, Cat>(&cat);
このようにすることで呼び出せた。impl Hoge<i32> for Cat {
などの行ですねtrait Fuga
にも fn bbb()
があったら、ってこと?protocol Hoge { associatedtype A func aaa() -> A //func bbb() -> Int } protocol HogeInt: Hoge { typealias A = Int func aaa() -> Int } protocol HogeString: Hoge { typealias A = String func aaa() -> String } struct Cat {} extension Cat: HogeInt { func aaa() -> Int { return 11 } //func bbb() -> Int { // return 22 //} } extension Cat: HogeString { func aaa() -> String { return "sss" } //func bbb() -> Int { // return 33 //} }
Hoge
の中身をコメントアウトすればコンパイルできる。func retAAA<H : Hoge>(h: H) -> H.A { return h.aaa() }
A
を推論して渡せる hoge
の型チェックをする。 let aaa: Int = retAAA(hoge)
func printAAA<H : Hoge>(h: H) { print(h.aaa()) }
これが何をprintするかを考えたときに (edited)protocol Hoge
および func printAAA
) とそれ以外が別モジュールだったらprotocol Hoge { associatedtype A func aaa() -> A } protocol HogeInt: Hoge where A == Int {} protocol HogeString: Hoge where A == String {} struct Cat {} extension Cat: HogeInt { typealias A = Int func aaa() -> Int { return 11 } } // error: 'HogeString' requires the types 'Cat.A' (aka 'Int') and 'String' be equivalent extension Cat: HogeString { func aaa() -> String { return "sss" } }
printAAA
みたいなのはどうなるの??associatedtype
で <H: Hoge>
と書けることと、ジェネリクスだと多重型パラ継承できるけど型パラ埋めないといけないから <H: Hoge>
相当のことができないことが対応してるのか。for key, value in dict: ...
正しくは for key, value in dict.items(): ...
map
と filter
なら内包表記で代替できますし、その二つがあれば大体問題ないんで。from typing import List list: List[int] = [2, 3, 5] squared: List[int] = [x * x for x in list]
Tuple[int, int]
とか書くのめんどくさい・・・ (edited)Callabble[[int, str], float]
とかもっとめんどくさい。 (edited)numpy.ndarray
に対して %
使ったりすると戻り値 ndarray
と解釈してくれない・・・。DIctionary
の新しいイニシャライザ相当のことができる。 (edited)// Swift let idToUser = [String: User](uniqueKeysWithValues: users.map { ($0.id, $0) })
(edited)# Python id_to_user = {user.id: user for user in users}
=>
を使えば↓でいけるのかな? let idToUser = users.map { ($0.id, $0) } => Dictionary.init
super.viewDidAppear(animated)
がないぞ?? https://github.com/JetBrains/kotlinconf-app/blob/master/ios/src/main/kotlin/ui/SessionsViewController.kt#L85-L87 (edited)do
記法のない Result
なんて使えたもんじゃないよ・・・。struct
と Kotlin の data class
にも書ける。Optional
実装する話をしてて、 Nothing
が bottom type なことと、 out
を使ってうまく実装できておもしろいです。 sealed class Optional<out T> { class Some<out T>(val value: T): Optional<T>() class None(): Optional<Nothing>() } fun main(args: Array<String>) { val a: Optional<Int> = Optional.None() // OK }
fun readResource(resourceName: String): ByteArray { val filePath = NSBundle.mainBundle.pathForResource(resourceName, ofType = null) val fileData = NSData.dataWithContentsOfFile(filePath!!) ?: throw Error("failed reading resource $resourceName") return fileData.bytes!!.readBytes(fileData.length.toInt()) }
(edited)?:
で throw
書けるのいいなぁ。 Nothing
が bottom type なのが利いてる。 (edited)Result
でやれってことなんでしょうけど、標準で用意されてないですよね?suspend
入れるけど throws
は入れないという判断が理解しかねる。do
記法が使えるから Result
でいいんです。for
式で。try/catch
と do
記法ってほとんど同じで( do
記法がエラー以外にも使える汎用的なものであることは別として)、現代の大抵の言語はそういうエラー処理機構を持ってるから、それなしでエラーと戦おうとすると辛いと思う。 (edited)try/catch
系を採用してる言語では、 Java が検査例外を導入したけど後続言語がみんな非検査例外に逃げちゃったから、 Java と Swift しかコンパイル時にチェックできる言語がない・・・。try!
相当のものと、 null safety 、 NumberFormatException
が非検査例外なこと、 Effective Java で推奨されてる例外の使い分けに従ってない API あたりが複合して使いづらくなってるけど、本質的には Java の検査例外でも Swift の throws/try
と同じような使い勝手を実現できると思う。try
ブロックはやっぱキツイですよ ブロック切れちゃうしtry
オペレータにしたのがかなり賢いと思うdo
ブロックだからそこは Swift でも同じじゃない? (edited)try
するのがSwiftでtry
済みになっちゃうのがJavaでtry!
がないことが一番辛い。## try! でエラーを握りつぶすことなくコンパイラを黙らせる この節で述べることは本投稿で **最も重要なこと** です。
(edited)try!
はあんまり使って無くて、代わりに自作関数の assertNoThrow(reason: String, f: () throws ->R)
を作って!
していい理由を明記するスタイルにしてるんですけどException
を throw
できるラムダ式に対応した interface
を一つ書けば OK か。 (edited)List
に map
ついてないのとかも。List
や Map
のリテラルがないのも。これは Kotlin もだけど。@NonNull
とかを解釈して API 読み替えて、 List
等のリテラルサポートして、 List
に map
したら Stream
にして map
して collect
してくれるような Java のプリプロセッサ(?)があれば Java でいい気もしてる。Int a = 42; Int? b = a; if (b != null) { List<Int> list = [a, b]; List<Int> square = list.map(x -> x * x); var Int c = square[0]; c = square[1]; }
が↓に変換されてくれるようなイメージ。 final int a = 42; @Nullable final Integer b = a; if (b != null) { @NotNull final Integer b_ = b; @NotNull final List<Integer> list = List<Integer>.of(a, b_); @NotNull final List<Integer> square = list.stream().map(x -> x * x).collect(Collectors.toList()); int c = square.get(0); c = square.get(1); }
static bool All(this IEnumerable<bool> thiz) { return thiz.Aggregate(true, (r, x) => r && x); }
while (condition) { // ... } while (condition);
みたいなコードを見つけてびっくりしたのだけど、C界隈ではあるあるネタなのかな?while (condition) { // ... }; while (condition) {};
という扱いっぽい}
で statement が完了してるのでは?;
を含まないと statement
じゃないんだったらif (<bool>) <statement> else <statement>
に対して <statement>
のところに { ... }
を埋めれなくなる。// JavaScript let a = 10; if (a <= 0) { console.log(a); } else while (a >= 0) { console.log(a); a--; }
https://qiita.com/ayies128/items/0e460b512d4698fc483d#comment-72ba84723db3df2ee909 (edited)condition
部分が両方同じなので、二つ目の while が意味なし。From
trait in crate std
.protocol ConstructibleFromValue<T> { init(_ value: T) }
protocol From { associated Convertible static func from(_ x: Convertible) -> Self } protocol AConvertible {} struct A: From { typealias Convertible = AConvertible static func from(_ x: Convertible) -> A { // ... } }
Sequence<Int>
と Sequence<Double>
に conform したら、 for
ループでどうなんの?みたいな話が書かれてる。for x: Int in xs { ... }
で良さそうですけどね。associatedtype
違いの conform できたら他にどんな問題が起こるでしょうか?Element
の型指定すりゃいいだけな気もするんですよね。struct Cat: Animal<Foo>, Animal<Bar>
だったとして、 Foo
と Bar
が共通の親を持ってたりしたら複雑そう。IntoIterator
trait in crate std
.trait Example { type Associated; } trait Example<Generic> { }
pub trait TryInto<T>: Sized { type Error; }
libcore/convert.rs
.handle
とスコープについて↓に書いてそう。 https://go.googlesource.com/proposal/+/master/design/go2draft-error-handling.md#handlerspackage main import ( "fmt" ) func main() { a := 2 { a := 3 fmt.Println(a) } fmt.Println(a) }
3 2
handle
と check
かなり良いのでは?catch
スコープの後ろに文が書けるのを無名スコープで再現できるなら、 handle
は defer
同様にネストを防げるのが良いところになるかな? defer
にできるけど finally
にできないことって他にあるっけ?
(edited)contract
で Swift のプロトコルみたいなことできそうでいい感じ。contract Equal(t T) { t == t }
associatedtype
じゃなくてジェネリクスの型パラメータ?contract
を型として使うことはできないんじゃない?contract convertible(_ To, f From) { To(f) } func FormatUnsigned(type T convertible(uint64, T))(v T) string { return strconv.FormatUint(uint64(v), 10) }
interface
もそうじゃないっけ?protocol
とダックタイピングのあいのこみたいなのになりそう。protocol
より強力なのか。Functor
書けないかと思ったけどわからん・・・。Each check may have a different handler chain function depending on the scope in which it is defined. For example, consider this function:
がまさにそこに言及していそう func process(user string, files chan string) (n int, err error) { handle err { return 0, fmt.Errorf("process: %v", err) } // handler A for i := 0; i < 3; i++ { handle err { err = fmt.Errorf("attempt %d: %v", i, err) } // handler B handle err { err = moreWrapping(err) } // handler C check do(something()) // check 1: handler chain C, B, A } check do(somethingElse()) // check 2: handler chain A }
(edited)Check 1, inside the loop, runs handlers C, B, and A, in that order. Note that because handle is lexically scoped, the handlers defined in the loop body do not accumulate on each new iteration, in contrast to defer.
defer
だとループした回数だけ実行?package main import ( "fmt" ) func main() { for i := 0; i < 3; i++ { defer fmt.Println(i) } fmt.Println("end") }
end 2 1 0
handle
ではエラーが発生したときに、スコープ抜けた分は実行されないということかと。func main() { for i := 0; i < 3; i++ { fmt.Println("a") defer fmt.Println(i) fmt.Println("b") } fmt.Println("end") }
a b a b a b end 2 1 0
for i in 0..<3 { print("loop \(i) begin") defer { print("defer \(i)") } print("loop \(i) end") }
loop 0 begin loop 0 end defer 0 loop 1 begin loop 1 end defer 1 loop 2 begin loop 2 end defer 2
defer
の違いで、 Swift の方がいいと思ってたけど、この前見た例で Go の defer
じゃないとできないのがあったんだよなぁ。何だったかなぁ・・・。defer
の挙動の違いは Error Handling Rationale and Proposal に書かれてる。 Swift は意図的にスコープ単位に改変して導入した。 Overall, I think it is better to use a Go-style defer than a Java-style try ... finally. ... Unlike Go, I think this should be tied to scope-exit, not to function-exit.
https://github.com/apple/swift/blob/master/docs/ErrorHandlingRationale.rst#clean-up-actions-1In some languages this would trigger a null pointer exception, but in Go it is common to write methods that gracefully handle being called with a nil receiver
https://tour.golang.org/methods/12mutating func
に、引数をポインタで受けるのが inout
引数に対応していておもしろい。 https://tour.golang.org/methods/4package main import "fmt" type I interface { M() } type T struct { S string } func (t *T) M() { if t == nil { fmt.Println("<nil>") return } fmt.Println(t.S) } func main() { var i I var t *T = nil i = t i.M() // OK i = nil i.M() // panic }
nil
の挙動が *T
経由のときと直接 I
に nil
を代入したときで異なってる。 (edited)<receiver>.<method of T>
の式が書けてmutating func
や inout
も ->
じゃなくて .
だし、そういう風にとらえると納得できそうな気持ちになってきた。 package main import "fmt" type Foo struct{ a int } func main() { f := Foo{a: 42} p := &f pp := &p fmt.Println(f.a) fmt.Println(p.a) // OK fmt.Println(pp.a) // NG }
inout
みたいなものかと。inout
はできないけど。func (t *T) M()
これが関数っぽく見えるけどメソッドだと思えばSwiftも似てるか。T
に対して mutating func
を書いてるととらえたら .
でコールできるのも自然に思える。self
引数があるだけの関数だし。*T
の nil
を代入するかで挙動が変わる件、インタフェースは (value, type)
のタプルのようなものと説明されていて、 *T
を代入した場合は (nil, *T)
になるけど、 i
に nil
を直接代入すると nil
になるんだと思う。type
はエイリアスではなくて別の型が作られるみたいなんだけど、 package main import "fmt" type Double float64 func main() { var a float64 = 42.0 var b Double = Double(a) // 明示的な変換が必要 fmt.Println(b) }
package main import "fmt" type Any interface{} func main() { var a interface{} = 42 var b Any = a // OK fmt.Println(b) }
(edited)package main import "fmt" type Foo interface{ A()int } type Bar Foo type ConcreteFoo struct{} func (t ConcreteFoo) A()int { return 42 } func main() { var a Foo = ConcreteFoo{} var b Bar = a fmt.Println(b.A()) }
interface
同士は互換性さえあれば OK なんだ。type InterfaceA InterfaceB
はタイプエイリアスのように働く。func (i int) Double()int { return i * 2 }
みたいに標準ライブラリの型に extension 的にメソッド生やせないの辛そう。 (edited)package main import "fmt" type Int int func (i Int) Double()Int { return i * 2 } func main() { var x Int = 42 fmt.Println(x.Double()) }
Int
に対して *
が使えたり 42
というリテラルが代入できたりする仕組みはまだわかってない。package main import "fmt" type path string func Save(p path) string { return "Saved" } func main() { var p path p = "/tmp/xxx" fmt.Println(Save(p)) // OK s := "/tmp/xxx" fmt.Println(Save(s)) // Compile Error fmt.Println(Save("/tmp/xxx")) // OK }
GoのtypeはSwiftと若干違うなと思ったことがあって、Goは2つ目のコードをコンパイルエラーにしてくれて、「おっ」と思ったけどリテラルを渡すことは防止できなかった。import Foundation typealias Path = String func save(path: Path) -> String { return "Saved" } var p: Path = "/tmp/xxx" print(save(path: p)) var s: String = "/tmp/xxx" print(save(path: s)) print(save(path: "/tmp/xxx"))
Swiftは全部通るはず。import Foundation typealias Path = String func save(path: Path) -> String { return "Saved" } var p: Path = "/tmp/xxx" print(save(path: p)) var s: String = "/tmp/xxx" print(save(path: s)) print(save(path: "/tmp/xxx"))
swift-4.1.1-RELEASE
Saved Saved Saved
ExpressibleByStringLiteral
相当のことができなさそうですし。package main import "fmt" type Int int func main() { var x Int = 42 var y int = int(x) fmt.Println(y) }
package main import ( "fmt" ) func main() { var a int = 42 // var b float64 = a // NG var b float64 = float64(a) // 明示的変換が必要 var c float64 = 42 // OK fmt.Println(b) fmt.Println(c) }
ExpressibleByXxx
相当のことが暗黙的に適用されるルールがありそう。package main import ( "fmt" ) type Foo struct{ A *int } func foo(a int) Foo { p := &a fmt.Println(p) f := Foo{A: p} fmt.Println(f.A) return f } func main() { f := foo(42) fmt.Println(f.A) }
main
側からみてもアドレスが変わらないのはなぜ?&a
をヒープにコピーするように判断してるってことか。package main import ( "fmt" ) type Foo struct{ A1 *int A2 *int A3 int A4 int } func foo(a int) Foo { p1 := &a p2 := &a p3 := &a p4 := &a fmt.Println(p1) fmt.Println(p2) fmt.Println(p3) fmt.Println(p4) f := Foo{ A1: p1, A2: p2, A3: *p3, A4: *p4, } fmt.Println(f.A1) fmt.Println(f.A2) return f } func main() { f := foo(42) fmt.Println(f.A1) fmt.Println(f.A2) }
0x10414020 0x10414020 0x10414020 0x10414020 0x10414020 0x10414020 0x10414020 0x10414020
&
で同じところを見るようになるのかな。ってか当たり前か。&
の時点じゃなくて a
が渡された時点でヒープに確保してる?a
にアクセスしても全部デリファレンスが走ってたりするのかな? (edited)await downloadImage(url).convert
try
も await
もひとつずつ書くのも嫌いじゃありません。let a = try foo(try bar())
(edited)int
型を Swift で Int32
型にキャストするのは面倒なので、コンパイル時に int
を 64 ビット扱いできたらいいなと思うのですが、そういうことって可能なのでしょうか?Swift.CInt
型です、そして、CInt
型がInt32型へのtypealiasになっています。 これはターゲット環境によってalias先が変化します。Int32
キャストするか C の方を int64_t
に全部書き換えるかですかねぇ。CInt
にキャストするほうがコードの意図が表現できて良いと思いますspasm_triplet *spasm_triplet_alloc(int n, int m, int nzmax, int prime, int with_values) {
これを let (n, m): (Int, Int) = size let nnz: Int = components.count let Atrip = spasm_triplet_alloc(n, m, nnz, 2, 1) // Cannot convert value of type 'Int' to expected argument type 'Int32'
とエラーが出ているので、 C の int
が Int32
になってるのかと思いました。 (edited)#define int int64_t
とか書いたのを足したらいいんじゃないですか。let (n, m): (Int, Int) = size let nnz: Int = components.count let Atrip = spasm_triplet_alloc(CInt(n), CInt(m), CInt(nnz), 2, 1)
僕ならこうしますねfunc rank() -> Int { let cA: UnsafeMutablePointer<spasm> = spasm_init(A) defer { spasm_csr_free(cA) } let rank = spasm_rank_hybrid(cA) return Int(rank) }
spasm_
とついてるのが C のライブラリです。これを Ubuntu で実行すると spasm_csr_free(cA)
の中で Segmentation Fault が発生します。 spasm_csr_free
の中でポインタのアドレスを出力してみると、spasm_init
で返されるポインタのアドレスから微妙に変わっています。であれば spasm_rank_hybrid
の中で何者かがアドレスを書き換えてるのだろうと思いきや、この関数の return の直前でアドレスを出力してみても init
で返されるものと同じになっているのです… C と Swift の連携によってアドレスが書き換わってるとしか思えない感じです… しかも不気味なことに func rank() -> Int { let cA: UnsafeMutablePointer<spasm> = spasm_init(A) print(cA) // ← これを入れるだけ defer { spasm_csr_free(cA) } let rank = spasm_rank_hybrid(cA) return Int(rank) }
こうすると Seg-Fault が発生しなくなります… (edited)defer
が悪さをしてるのかと思って func rank() -> Int { let cA: UnsafeMutablePointer<spasm> = spasm_init(A) let rank = spasm_rank_hybrid(cA) spasm_csr_free(cA) return Int(rank) }
としてみましたが同じでしたspasm_init: 0x7f3051b1c8f0 start of spasm_rank_hybrid: 0x7f3051b1c8f0 end of spasm_rank_hybrid: 0x7f3051b1c8f0 spasm_csr_free: 0x7f3051b1c800
こういう感じで、アドレスが f0
分ズレるという…f0
ズレるんじゃなくて & 00
されるようですprivate func spasm_init(_ A: DMatrix<LinearSolver.R>) -> UnsafeMutablePointer<spasm> // `spasm_init` は Swift 製のラッパー関数で、その中で ↓ `spasm_compress` を呼んで返しています func spasm_compress(_ T: UnsafePointer<spasm_triplet>!) -> UnsafeMutablePointer<spasm>! func spasm_rank_hybrid(_ A: UnsafeMutablePointer<spasm>!, _ sparsity_threshold: Double) -> Int32 func spasm_csr_free(_ A: UnsafeMutablePointer<spasm>!)
(edited)UnsafeMutablePointer<spasm>!
にしてみましたが,やはりダメでした orzspasm
はSwiftからどう見えてますか?struct spasm
としか出てきません.C の実装は ↓ です typedef struct { /* matrix in compressed-sparse row format */ int nzmax; /* maximum number of entries */ int n; /* number of rows */ int m; /* number of columns */ int *p; /* row pointers (size n+1) */ int *j; /* column indices, size nzmax */ spasm_GFp *x; /* numerical values, size nzmax (optional) */ int prime; } spasm;
intptr_t
で受け渡しすると動くと思います https://cpprefjp.github.io/reference/cstdint/intptr_t.htmlintptr_t spasm_compress_workaround(...) { return spasm_compress(...); } void spasm_csr_free_workaround(intptr_t pointer) { spasm_csr_free((spasm *)pointer); }
spasm_init
のSwiftコードが見たいです。 (edited)private func spasm_init(_ A: DMatrix<R>) -> UnsafeMutablePointer<spasm> { let nnz = A.components.count let Atrip = spasm_triplet_alloc(CInt(A.size.1), CInt(A.size.0), CInt(nnz), CInt(p.intValue), 1) // note: transposed for c in A.components { spasm_add_entry(Atrip, CInt(c.col), CInt(c.row), CInt(c.value.representative)) // note: transposed } let ptr = spasm_compress(Atrip)! spasm_triplet_free(Atrip) return ptr }
こちらです。行列の要素をセットして CSR 形式に圧縮しています。 (edited)DMatrix<R>
が自作の行列型です。printf("%p", A);
こういうやつです. (edited)spasm_rank_hybrid
の始まりと return の直前にこれを入れてます。spasm_csr_free
をラップしたSwiftの関数を用意したら直ります?func spasm_csr_free_swift(ptr: UnsafePointer<spasm>) { spasm_csr_free(ptr) }
print(ptr)
を入れると直りますwspasm
型の定義ぐらいですねman 2 open
互換なFile Descriptorを触れますが・・・FILE*
の方は無いかも・・・?FILE*
から fd は取れるんですけど (man 3 fileno
)FILE*
は取れない (ライブラリとしての抽象度が高い)FILE*
はファイルの抽象だけど、たしかにfmemopenでいけそうclass Read { var value: String { get { _value } } var _value: String = "" } class WriteRead: Read { private(set) override var value: String { get { super._value } set { super._value = newValue } } }
val
はSwiftでいうと let
というより get only var
に似てる。 親クラスの実フィールドがprivateなときは同じようにはできない。 (edited)async function
の戻り値の型が Promise
でないといけないのって冗長じゃない?見た目上は(普通は)非 Promise
な値を return
するわけだし、 async
なら Promise
返すってわかってるんだから戻り値の型に Promise
要らない気がするんだけど・・・。 C# に引きづられてる?async
は内向けのものでしかないですよね。外に向けた型ではなく、単にその関数の中で await
が使えるよと。 (edited)Promise
を返すという型で表現する。 Swift の async/await
とは根本的に思想が違いますね・・・。 (edited)Promise<boolean>
を返す API を呼んで await
付け忘れて if
に突っ込んでバグっててハマった・・・。もう === true
とかで検査した方が安全なんじゃないか。それなら Promise<boolean>
と boolean
の比較なんで tsc が検出してくれる。io.Reader
的なものがSwiftにもあれば良かったのに。 type Reader interface { Read(p []byte) (n int, err error) }
(edited)