iota(BigInt) too

[dlangBugzillaToGithub]

bearophile_hugs reported this on 2011-08-06T19:56:56Z

Transfered from https://issues.dlang.org/show_bug.cgi?id=6447

CC List

• dmitry.olsh (DmitryOlshansky)
• hsteoh
• issues.dlang (jmdavis)
• russel

Description

Sometimes I'd like to generate a range of bigints too:

Enhancement:

import std.bigint: BigInt;
import std.range: iota;
void main() {
    auto x = iota(BigInt(10));
}

Currently DMD gives:

...\std\range.d(4028): Error: template std.range.iota(B,E,S) if ((isIntegral!(CommonType!(B,E)) || isPointer!(CommonType!(B,E))) && isIntegral!(S)) does not match any function template declaration
...\std\range.d(4028): Error: template std.range.iota(B,E,S) if ((isIntegral!(CommonType!(B,E)) || isPointer!(CommonType!(B,E))) && isIntegral!(S)) cannot deduce template function from argument types !()(BigInt,BigInt)
test.d(4): Error: template instance std.range.iota!(BigInt) error instantiating

[dlangBugzillaToGithub]

issues.dlang commented on 2011-08-06T20:05:50Z

BigInt isn't considered an integral by isIntegral, hence why it doesn't work. We should probably look at having a template in std.traits which covers both the built-in integral types and BigInt so that those functions which can work with both have an easy way to test for it. It's either that or every function that could use BigInt is going to have to test for it explicitly on top of testing for isIntegral.

Regardless, I don't see any reason why using iota with BigInt shouldn't be made to work.

[dlangBugzillaToGithub]

russel commented on 2013-05-28T03:37:57Z

I don't have the time, and likely not the knowledge, to fix this and provide a pull request. Is there anyone who does? This is a two year old problem that means D is not useful for applications using data types other than the hardware types, which is a lot of applications.

Is this a symptom of the fact that Phobos is really predicated on use of hardware types more generally?

(This comment is really to get me on the cc list as there seems to be a requirement to make a comment in order to add oneself to the cc list :-((

[dlangBugzillaToGithub]

bearophile_hugs commented on 2013-05-28T04:15:16Z

(In reply to comment #2)

> Is this a symptom of the fact that Phobos is really predicated on use of
> hardware types more generally?

I think it's mostly a symptom of D/Phobos not having many contributors :-)

[dlangBugzillaToGithub]

hsteoh commented on 2013-08-18T22:39:52Z

Related: issue #10762.

[dlangBugzillaToGithub]

bearophile_hugs commented on 2014-12-04T23:53:02Z

A workaround:

10.iota.map!BigInt

[dlangBugzillaToGithub]

hsteoh commented on 2014-12-05T00:12:34Z

That doesn't help when you actually *need* a BigInt, e.g., iota(BigInt(2)^^65536). Of course, you'd run into other problems with that (e.g., you'll be waiting a looong time for your program to finish), but the idea is that you want to iterate over numbers that only BigInt can represent, right?

[dlangBugzillaToGithub]

bearophile_hugs commented on 2014-12-05T00:23:49Z

(In reply to hsteoh from comment #6)
> That doesn't help when you actually *need* a BigInt, e.g.,
> iota(BigInt(2)^^65536). Of course, you'd run into other problems with that
> (e.g., you'll be waiting a looong time for your program to finish), but the
> idea is that you want to iterate over numbers that only BigInt can
> represent, right?

The idea is that I'd like iota(BigInt(10)) to work. In the meantime I use some workarounds.

[dlangBugzillaToGithub]

hsteoh commented on 2014-12-05T00:54:51Z

Yes, but if BigInt(10) should work, then BigInt(2)^^65536 should work too. I don't think you'd like it if the library imposed some arbitrary subrange on your numeric types that may be used with iota (what if iota(10) worked but iota(11) didn't?).

[dlangBugzillaToGithub]

bearophile_hugs commented on 2014-12-05T01:03:23Z

(In reply to hsteoh from comment #8)
> Yes, but if BigInt(10) should work, then BigInt(2)^^65536 should work too. I
> don't think you'd like it if the library imposed some arbitrary subrange on
> your numeric types that may be used with iota (what if iota(10) worked but
> iota(11) didn't?).

Yes, of course. I'd like iota to work with bigints in general :-)

[dlangBugzillaToGithub]

hsteoh commented on 2015-01-22T18:22:31Z

This seems to be a subset of https://issues.dlang.org/show_bug.cgi?id=10762

[dlangBugzillaToGithub]

hsteoh commented on 2015-01-22T18:22:45Z

https://github.com/D-Programming-Language/phobos/pull/2895

[dlangBugzillaToGithub]

github-bugzilla commented on 2015-01-26T09:27:04Z

Commit pushed to master at https://github.com/D-Programming-Language/phobos

https://github.com/D-Programming-Language/phobos/commit/b159a5bdc980abb90833b32fa04044a002dfc794
Merge pull request #2895 from quickfur/iota_bigint

Issue 6447 & 10762: support user-defined types in iota()

[dlangBugzillaToGithub]

bearophile_hugs commented on 2015-01-26T12:23:10Z

I keep this issue open because this still doesn't work:

void main() {
    import std.bigint: BigInt;
    import std.range: iota;
    iota(BigInt(1), BigInt(100), BigInt(5));
    iota(BigInt(1), BigInt(100), 5);
}

test.d(4,9): Error: template std.range.iota cannot deduce function from argument types !()(BigInt, BigInt, BigInt), candidates are:
...\dmd2\src\phobos\std\range\package.d(4008,6):        std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)
...\dmd2\src\phobos\std\range\package.d(4098,6):        std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))
...\dmd2\src\phobos\std\range\package.d(4105,6):        std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
...\dmd2\src\phobos\std\range\package.d(4168,6):        std.range.iota(E)(E end)
...\dmd2\src\phobos\std\range\package.d(4176,6):        std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))
test.d(4,9):        ... (1 more, -v to show) ...
test.d(5,9): Error: template std.range.iota cannot deduce function from argument types !()(BigInt, BigInt, int), candidates are:
...\dmd2\src\phobos\std\range\package.d(4008,6):        std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)
...\dmd2\src\phobos\std\range\package.d(4098,6):        std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))
...\dmd2\src\phobos\std\range\package.d(4105,6):        std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
...\dmd2\src\phobos\std\range\package.d(4168,6):        std.range.iota(E)(E end)
...\dmd2\src\phobos\std\range\package.d(4176,6):        std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))
test.d(5,9):        ... (1 more, -v to show) ...

[dlangBugzillaToGithub]

hsteoh commented on 2015-01-26T16:16:50Z

One thing at a time! The last PR implemented the iota(start,end) case. The next step is to extend it to handle the iota(start,end,step) case when += is supported.

[dlangBugzillaToGithub]

github-bugzilla commented on 2015-02-18T03:41:30Z

Commit pushed to 2.067 at https://github.com/D-Programming-Language/phobos

https://github.com/D-Programming-Language/phobos/commit/b159a5bdc980abb90833b32fa04044a002dfc794
Merge pull request #2895 from quickfur/iota_bigint

[dlangBugzillaToGithub]

dmitry.olsh commented on 2018-05-29T14:03:57Z

Works now.

[dlangBugzillaToGithub]

russel commented on 2018-06-05T10:22:47Z

Using LDC on Debian Sid, the code:

import std.bigint: BigInt;
import std.range: iota;
void main() {
    auto x = iota(BigInt(10));
}

compiles and executes fine, but the code:

void main() {
    import std.bigint: BigInt;
    import std.range: iota;
    iota(BigInt(1), BigInt(100), BigInt(5));
    iota(BigInt(1), BigInt(100), 5);
}

results in:

test_b.d(4): Error: template std.range.iota cannot deduce function from argument types !()(BigInt, BigInt, BigInt), candidates are:
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5371):        std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5481):        std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5488):        std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5558):        std.range.iota(E)(E end) if (is(typeof(iota(E(0), end))))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5567):        std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))
test_b.d(4):        ... (1 more, -v to show) ...
test_b.d(5): Error: template std.range.iota cannot deduce function from argument types !()(BigInt, BigInt, int), candidates are:
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5371):        std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5481):        std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5488):        std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5558):        std.range.iota(E)(E end) if (is(typeof(iota(E(0), end))))
/usr/lib/ldc/x86_64-linux-gnu/include/d/std/range/package.d(5567):        std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))
test_b.d(5):        ... (1 more, -v to show) ...

Using dmd from d-apt the first code works fine and the second code results in:

test_b.d(4): Error: template `std.range.iota` cannot deduce function from argument types `!()(BigInt, BigInt, BigInt)`, candidates are:
/usr/include/dmd/phobos/std/range/package.d(5890):        `std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)`
/usr/include/dmd/phobos/std/range/package.d(6000):        `std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))`
/usr/include/dmd/phobos/std/range/package.d(6007):        `std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))`
/usr/include/dmd/phobos/std/range/package.d(6077):        `std.range.iota(E)(E end) if (is(typeof(iota(E(0), end))))`
/usr/include/dmd/phobos/std/range/package.d(6086):        `std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))`
test_b.d(4):        ... (1 more, -v to show) ...
test_b.d(5): Error: template `std.range.iota` cannot deduce function from argument types `!()(BigInt, BigInt, int)`, candidates are:
/usr/include/dmd/phobos/std/range/package.d(5890):        `std.range.iota(B, E, S)(B begin, E end, S step) if ((isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E))) && isIntegral!S)`
/usr/include/dmd/phobos/std/range/package.d(6000):        `std.range.iota(B, E)(B begin, E end) if (isFloatingPoint!(CommonType!(B, E)))`
/usr/include/dmd/phobos/std/range/package.d(6007):        `std.range.iota(B, E)(B begin, E end) if (isIntegral!(CommonType!(B, E)) || isPointer!(CommonType!(B, E)))`
/usr/include/dmd/phobos/std/range/package.d(6077):        `std.range.iota(E)(E end) if (is(typeof(iota(E(0), end))))`
/usr/include/dmd/phobos/std/range/package.d(6086):        `std.range.iota(B, E, S)(B begin, E end, S step) if (isFloatingPoint!(CommonType!(B, E, S)))`
test_b.d(5):        ... (1 more, -v to show) ...

So I think this problem is not fixed.