テキスト比較

2 つのテキストファイルの違いを見つける

ライブエディター

空白の変更を非表示

未変更行を折りたたむ

折り返しなし

レイアウト

比較精度

テキストスタイル

シンタックスハイライト

Diffchecker Desktop Diffcheckerを実行する最も安全な方法。Diffchecker Desktopアプリを入手：あなたの差分はコンピューターから出ることはありません！Desktopを入手

Untitled diff

作成日昨年差分は期限切れになりません

19 削除

行
合計
削除

文字
合計
削除

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

54 行

31 追加

行
合計
追加

文字
合計
追加

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

63 行

const std = @import("std");

// Cache requires a function (lambda) to be called when there's no cache hit and an other function(args_to_u64) that can compute args

// of the function to u64 that becomes the identifier to compare same arguments.

pub fn Cache(lambda: anytype, args_to_u64: fn (anytype) u64) type {

const lambda_info = @typeInfo(@TypeOf(lambda));

@compileLog(lambda_info);

if (lambda_info != .@"fn") {

if (lambda_info != .Fn) {

@compileError("lambda should be a function type");

}

const return_type = lambda_info.Fn.return_type orelse @compileError("No return type");

const return_type = lambda_info.@"fn".return_type orelse @compileError("No return type");

@compileLog(return_type);

const InnerHashMap = std.HashMap(u64, return_type, struct {

pub fn hash(_: @This(), key: u64) u64 {

return key;

}

pub fn eql(_: @This(), a: u64, b: u64) bool {

return a == b;

}

}, 80);

return struct {

_inner: std.HashMap(u64, return_type, struct {

_inner: InnerHashMap,

fn hash(_: @This(), key: u64) u64 {

return key;

}

fn eql(_: @This(), a: u64, b: u64) bool {

return a == b;

}

}, 80),

const Self = @This();

fn init(allocator: std.mem.Allocator) Cache(lambda, args_to_u64) {

return Self{ ._inner = std.StringHashMap(return_type).init(allocator) };

return Self{ ._inner = InnerHashMap.init(allocator) };

}

fn get(self: *Self, args: anytype) return_type {

fn get(self: *Self, args: anytype) !return_type {

const key = args_to_u64(args);

const value = self._inner.get(key) orelse @call(.{}, lambda, args);

if (self._inner.get(key)) |value| {

return value;

std.debug.print("Rertrieving from cache for the key: {d}\n", .{key});

return value;

} else {

std.debug.print("Computing function and storing in cache for the key: {d}\n", .{key});

const value = @call(.auto, lambda, args);

try self._inner.put(key, value);

return value;

}

};

}

// Below tests addition of two numbers and cache

// Below tests to cache addition of two numbers

fn _add(a: u64, b: u64) u64 {

return a + b;

}

const HashAdd = struct {

var allocator: std.mem.Allocator = undefined;

pub fn hash_add(args: anytype) u64 {

const temp = std.fmt.allocPrint(allocator, "{}:{}", .{ args[0], args[1] }) catch unreachable;

defer allocator.free(temp);

return std.hash_map.hashString(temp);

}

};

test "test_cache" {

const allocator = std.testing.allocator;

HashAdd.allocator = allocator;

var cache = Cache(_add, HashAdd.hash_add).init(allocator);

const value: u64 = cache.get(.{ 1, 2 });

const value: u64 = try cache.get(.{ 1, 2 });

try std.testing.expectEqual(3, value);

const cache_value: u64 = try cache.get(.{ 1, 2 });

try std.testing.expectEqual(3, cache_value);

cache._inner.deinit();

}

保存された差分

原文

ファイルを開く

const std = @import("std");

// Cache requires a function (lambda) to be called when there's no cache hit and an other function(args_to_u64) that can compute args
// of the function to u64 that becomes the identifier to compare same arguments.
pub fn Cache(lambda: anytype, args_to_u64: fn (anytype) u64) type {
    const lambda_info = @typeInfo(@TypeOf(lambda));
    @compileLog(lambda_info);
    if (lambda_info != .Fn) {
        @compileError("lambda should be a function type");
    }
    const return_type = lambda_info.Fn.return_type orelse @compileError("No return type");
    @compileLog(return_type);
    return struct {
        _inner: std.HashMap(u64, return_type, struct {
            fn hash(_: @This(), key: u64) u64 {
                return key;
            }
            fn eql(_: @This(), a: u64, b: u64) bool {
                return a == b;
            }
        }, 80),
        const Self = @This();
        fn init(allocator: std.mem.Allocator) Cache(lambda, args_to_u64) {
            return Self{ ._inner = std.StringHashMap(return_type).init(allocator) };
        }
        fn get(self: *Self, args: anytype) return_type {
            const key = args_to_u64(args);
            const value = self._inner.get(key) orelse @call(.{}, lambda, args);
            return value;
        }
    };
}

// Below tests addition of two numbers and cache
fn _add(a: u64, b: u64) u64 {
    return a + b;
}
const HashAdd = struct {
    var allocator: std.mem.Allocator = undefined;
    pub fn hash_add(args: anytype) u64 {
        const temp = std.fmt.allocPrint(allocator, "{}:{}", .{ args[0], args[1] }) catch unreachable;
        defer allocator.free(temp);
        return std.hash_map.hashString(temp);
    }
};

test "test_cache" {
    const allocator = std.testing.allocator;
    HashAdd.allocator = allocator;
    var cache = Cache(_add, HashAdd.hash_add).init(allocator);
    const value: u64 = cache.get(.{ 1, 2 });
    try std.testing.expectEqual(3, value);
    cache._inner.deinit();
}

変更されたテキスト

ファイルを開く

const std = @import("std");

// Cache requires a function (lambda) to be called when there's no cache hit and an other function(args_to_u64) that can compute args
// of the function to u64 that becomes the identifier to compare same arguments.
pub fn Cache(lambda: anytype, args_to_u64: fn (anytype) u64) type {
    const lambda_info = @typeInfo(@TypeOf(lambda));
    if (lambda_info != .@"fn") {
        @compileError("lambda should be a function type");
    }
    const return_type = lambda_info.@"fn".return_type orelse @compileError("No return type");
    const InnerHashMap = std.HashMap(u64, return_type, struct {
        pub fn hash(_: @This(), key: u64) u64 {
            return key;
        }
        pub fn eql(_: @This(), a: u64, b: u64) bool {
            return a == b;
        }
    }, 80);
    return struct {
        _inner: InnerHashMap,
        const Self = @This();
        fn init(allocator: std.mem.Allocator) Cache(lambda, args_to_u64) {
            return Self{ ._inner = InnerHashMap.init(allocator) };
        }
        fn get(self: *Self, args: anytype) !return_type {
            const key = args_to_u64(args);
            if (self._inner.get(key)) |value| {
                std.debug.print("Rertrieving from cache for the key: {d}\n", .{key});
                return value;
            } else {
                std.debug.print("Computing function and storing in cache for the key: {d}\n", .{key});
                const value = @call(.auto, lambda, args);
                try self._inner.put(key, value);
                return value;
            }
        }
    };
}

// Below tests to cache addition of two numbers
fn _add(a: u64, b: u64) u64 {
    return a + b;
}
const HashAdd = struct {
    var allocator: std.mem.Allocator = undefined;
    pub fn hash_add(args: anytype) u64 {
        const temp = std.fmt.allocPrint(allocator, "{}:{}", .{ args[0], args[1] }) catch unreachable;
        defer allocator.free(temp);
        return std.hash_map.hashString(temp);
    }
};

test "test_cache" {
    const allocator = std.testing.allocator;
    HashAdd.allocator = allocator;
    var cache = Cache(_add, HashAdd.hash_add).init(allocator);
    const value: u64 = try cache.get(.{ 1, 2 });
    try std.testing.expectEqual(3, value);
    const cache_value: u64 = try cache.get(.{ 1, 2 });
    try std.testing.expectEqual(3, cache_value);
    cache._inner.deinit();
}